home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / orca / speechdispatcherfactory.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  14.6 KB  |  396 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Provides an Orca speech server for Speech Dispatcher backend.
  5.  
  6. NOTE: THIS IS EXPERIMENTAL ONLY AND IS NOT A SUPPORTED COMPONENT OF ORCA.
  7. '''
  8. __id__ = '$Id: speechdispatcherfactory.py 4659 2009-03-30 17:37:48Z wwalker $'
  9. __version__ = '$Revision: 4659 $'
  10. __date__ = '$Date: 2009-03-30 13:37:48 -0400 (Mon, 30 Mar 2009) $'
  11. __author__ = 'Tomas Cerha <cerha@brailcom.org>'
  12. __copyright__ = 'Copyright (c) 2006-2008 Brailcom, o.p.s.'
  13. __license__ = 'LGPL'
  14. import gobject
  15. import debug
  16. import speechserver
  17. import settings
  18. import orca
  19. from acss import ACSS
  20. from orca_i18n import _
  21.  
  22. try:
  23.     import speechd
  24. except:
  25.     _speechd_available = False
  26.  
  27. _speechd_available = True
  28.  
  29. try:
  30.     getattr(speechd, 'CallbackType')
  31. except AttributeError:
  32.     _speechd_version_ok = False
  33.  
  34. _speechd_version_ok = True
  35.  
  36. class SpeechServer(speechserver.SpeechServer):
  37.     _active_servers = { }
  38.     DEFAULT_SERVER_ID = 'default'
  39.     _SERVER_NAMES = {
  40.         DEFAULT_SERVER_ID: _('Default Synthesizer') }
  41.     KEY_NAMES = {
  42.         '_': 'underscore',
  43.         'space': 'space',
  44.         '"': 'double-quote' }
  45.     
  46.     def getFactoryName():
  47.         return _('Speech Dispatcher')
  48.  
  49.     getFactoryName = staticmethod(getFactoryName)
  50.     
  51.     def getSpeechServers():
  52.         servers = []
  53.         default = SpeechServer._getSpeechServer(SpeechServer.DEFAULT_SERVER_ID)
  54.         if default is not None:
  55.             servers.append(default)
  56.             for module in default.list_output_modules():
  57.                 servers.append(SpeechServer._getSpeechServer(module))
  58.             
  59.         
  60.         return servers
  61.  
  62.     getSpeechServers = staticmethod(getSpeechServers)
  63.     
  64.     def _getSpeechServer(cls, serverId):
  65.         """Return an active server for given id.
  66.  
  67.         Attempt to create the server if it doesn't exist yet.  Returns None
  68.         when it is not possible to create the server.
  69.         
  70.         """
  71.         if serverId not in cls._active_servers:
  72.             cls(serverId)
  73.         
  74.         return cls._active_servers.get(serverId)
  75.  
  76.     _getSpeechServer = classmethod(_getSpeechServer)
  77.     
  78.     def getSpeechServer(info = None):
  79.         if info is not None:
  80.             thisId = info[1]
  81.         else:
  82.             thisId = SpeechServer.DEFAULT_SERVER_ID
  83.         return SpeechServer._getSpeechServer(thisId)
  84.  
  85.     getSpeechServer = staticmethod(getSpeechServer)
  86.     
  87.     def shutdownActiveServers():
  88.         for server in SpeechServer._active_servers.values():
  89.             server.shutdown()
  90.         
  91.  
  92.     shutdownActiveServers = staticmethod(shutdownActiveServers)
  93.     
  94.     def __init__(self, serverId):
  95.         super(SpeechServer, self).__init__()
  96.         self._id = serverId
  97.         self._client = None
  98.         self._current_voice_properties = { }
  99.         self._acss_manipulators = ((ACSS.RATE, self._set_rate), (ACSS.AVERAGE_PITCH, self._set_pitch), (ACSS.GAIN, self._set_volume), (ACSS.FAMILY, self._set_family))
  100.         if not _speechd_available:
  101.             debug.println(debug.LEVEL_WARNING, 'Speech Dispatcher interface not installed.')
  102.             return None
  103.         if not _speechd_version_ok:
  104.             debug.println(debug.LEVEL_WARNING, 'Speech Dispatcher version 0.6.2 or later is required.')
  105.             return None
  106.         self._PUNCTUATION_MODE_MAP = {
  107.             settings.PUNCTUATION_STYLE_ALL: speechd.PunctuationMode.ALL,
  108.             settings.PUNCTUATION_STYLE_MOST: speechd.PunctuationMode.SOME,
  109.             settings.PUNCTUATION_STYLE_SOME: speechd.PunctuationMode.SOME,
  110.             settings.PUNCTUATION_STYLE_NONE: speechd.PunctuationMode.NONE }
  111.         self._CALLBACK_TYPE_MAP = {
  112.             speechd.CallbackType.BEGIN: speechserver.SayAllContext.PROGRESS,
  113.             speechd.CallbackType.CANCEL: speechserver.SayAllContext.INTERRUPTED,
  114.             speechd.CallbackType.END: speechserver.SayAllContext.COMPLETED }
  115.         self._default_voice_name = _('%s default voice') % serverId
  116.         
  117.         try:
  118.             self._init()
  119.         except:
  120.             _speechd_version_ok
  121.             _speechd_available
  122.             debug.println(debug.LEVEL_WARNING, 'Speech Dispatcher service failed to connect:')
  123.             debug.printException(debug.LEVEL_WARNING)
  124.  
  125.         SpeechServer._active_servers[serverId] = self
  126.  
  127.     
  128.     def _init(self):
  129.         self._client = client = speechd.SSIPClient('Orca', component = self._id)
  130.         if self._id != self.DEFAULT_SERVER_ID:
  131.             client.set_output_module(self._id)
  132.         
  133.         self._current_voice_properties = { }
  134.         mode = self._PUNCTUATION_MODE_MAP[settings.verbalizePunctuationStyle]
  135.         client.set_punctuation(mode)
  136.  
  137.     
  138.     def _send_command(self, command, *args, **kwargs):
  139.         if hasattr(speechd, 'SSIPCommunicationError'):
  140.             
  141.             try:
  142.                 return command(*args, **kwargs)
  143.             except speechd.SSIPCommunicationError:
  144.                 debug.println(debug.LEVEL_CONFIGURATION, 'Speech Dispatcher connection lost. Trying to reconnect.')
  145.                 self.reset()
  146.                 return command(*args, **kwargs)
  147.             
  148.  
  149.         None<EXCEPTION MATCH>speechd.SSIPCommunicationError
  150.         return command(*args, **kwargs)
  151.  
  152.     
  153.     def _set_rate(self, acss_rate):
  154.         rate = int(2 * max(0, min(99, acss_rate)) - 98)
  155.         self._send_command(self._client.set_rate, rate)
  156.  
  157.     
  158.     def _set_pitch(self, acss_pitch):
  159.         pitch = int(20 * max(0, min(9, acss_pitch)) - 90)
  160.         self._send_command(self._client.set_pitch, pitch)
  161.  
  162.     
  163.     def _set_volume(self, acss_volume):
  164.         volume = int(15 * max(0, min(9, acss_volume)) - 35)
  165.         self._send_command(self._client.set_volume, volume)
  166.  
  167.     
  168.     def _set_family(self, acss_family):
  169.         locale = acss_family[speechserver.VoiceFamily.LOCALE]
  170.         if locale:
  171.             lang = locale.split('_')[0]
  172.             if lang and len(lang) == 2:
  173.                 self._send_command(self._client.set_language, lang)
  174.             
  175.         
  176.         
  177.         try:
  178.             set_synthesis_voice = self._client.set_synthesis_voice
  179.         except AttributeError:
  180.             pass
  181.  
  182.         name = acss_family[speechserver.VoiceFamily.NAME]
  183.         if name != self._default_voice_name:
  184.             self._send_command(set_synthesis_voice, name)
  185.         
  186.  
  187.     
  188.     def _apply_acss(self, acss):
  189.         if acss is None:
  190.             acss = settings.voices[settings.DEFAULT_VOICE]
  191.         
  192.         current = self._current_voice_properties
  193.         for acss_property, method in self._acss_manipulators:
  194.             value = acss.get(acss_property)
  195.             if value is not None and current.get(acss_property) != value:
  196.                 method(value)
  197.                 current[acss_property] = value
  198.                 continue
  199.         
  200.  
  201.     
  202.     def _speak(self, text, acss, **kwargs):
  203.         self._apply_acss(acss)
  204.         self._send_command(self._client.speak, text, **kwargs)
  205.  
  206.     
  207.     def _say_all(self, iterator, orca_callback):
  208.         '''Process another sayAll chunk.
  209.  
  210.         Called by the gidle thread.
  211.  
  212.         '''
  213.         
  214.         try:
  215.             (context, acss) = iterator.next()
  216.         except StopIteration:
  217.             pass
  218.  
  219.         
  220.         def callback(callbackType, index_mark = (None, None, None, None)):
  221.             t = self._CALLBACK_TYPE_MAP[callbackType]
  222.             if t == speechserver.SayAllContext.PROGRESS:
  223.                 if index_mark:
  224.                     context.currentOffset = int(index_mark)
  225.                 else:
  226.                     context.currentOffset = context.startOffset
  227.             elif t == speechserver.SayAllContext.COMPLETED:
  228.                 context.currentOffset = context.endOffset
  229.             
  230.             gobject.idle_add(orca_callback, context, t)
  231.             if t == speechserver.SayAllContext.COMPLETED:
  232.                 gobject.idle_add(self._say_all, iterator, orca_callback)
  233.             
  234.  
  235.         self._speak(context.utterance, acss, callback = callback, event_types = self._CALLBACK_TYPE_MAP.keys())
  236.         return False
  237.  
  238.     
  239.     def _cancel(self):
  240.         self._send_command(self._client.cancel)
  241.  
  242.     
  243.     def _change_default_speech_rate(self, decrease = False):
  244.         acss = settings.voices[settings.DEFAULT_VOICE]
  245.         if not decrease or -1:
  246.             pass
  247.         delta = settings.speechRateDelta * +1
  248.         rate = acss[ACSS.RATE]
  249.         acss[ACSS.RATE] = max(0, min(99, rate + delta))
  250.         debug.println(debug.LEVEL_CONFIGURATION, 'Speech rate is now %d' % rate)
  251.         if not decrease or _('slower.'):
  252.             pass
  253.         self.speak(_('faster.'), acss = acss)
  254.  
  255.     
  256.     def _change_default_speech_pitch(self, decrease = False):
  257.         acss = settings.voices[settings.DEFAULT_VOICE]
  258.         if not decrease or -1:
  259.             pass
  260.         delta = settings.speechPitchDelta * +1
  261.         pitch = acss[ACSS.AVERAGE_PITCH]
  262.         acss[ACSS.AVERAGE_PITCH] = max(0, min(9, pitch + delta))
  263.         debug.println(debug.LEVEL_CONFIGURATION, 'Speech pitch is now %d' % pitch)
  264.         if not decrease or _('lower.'):
  265.             pass
  266.         self.speak(_('higher.'), acss = acss)
  267.  
  268.     
  269.     def getInfo(self):
  270.         return [
  271.             self._SERVER_NAMES.get(self._id, self._id),
  272.             self._id]
  273.  
  274.     
  275.     def getVoiceFamilies(self):
  276.         getlocale = getlocale
  277.         LC_MESSAGES = LC_MESSAGES
  278.         import locale
  279.         locale = getlocale(LC_MESSAGES)[0]
  280.         if locale is None or locale == 'C':
  281.             lang = None
  282.         else:
  283.             lang = locale.split('_')[0]
  284.         voices = ((self._default_voice_name, lang, None),)
  285.         
  286.         try:
  287.             list_synthesis_voices = self._client.list_synthesis_voices
  288.         except AttributeError:
  289.             pass
  290.  
  291.         voices += self._send_command(list_synthesis_voices)
  292.         families = [ speechserver.VoiceFamily({
  293.             speechserver.VoiceFamily.NAME: name,
  294.             speechserver.VoiceFamily.LOCALE: lang }) for name, lang, dialect in voices ]
  295.         return families
  296.  
  297.     
  298.     def speak(self, text = None, acss = None, interrupt = True):
  299.         if text:
  300.             self._speak(text, acss)
  301.         
  302.  
  303.     
  304.     def queueText(self, text = '', acss = None):
  305.         if text:
  306.             self._speak(text, acss)
  307.         
  308.  
  309.     
  310.     def speakUtterances(self, utteranceList, acss = None, interrupt = True):
  311.         for utterance in utteranceList:
  312.             if utterance:
  313.                 self._speak(utterance, acss)
  314.                 continue
  315.         
  316.  
  317.     
  318.     def sayAll(self, utteranceIterator, progressCallback):
  319.         gobject.idle_add(self._say_all, utteranceIterator, progressCallback)
  320.  
  321.     
  322.     def speakCharacter(self, character, acss = None):
  323.         self._apply_acss(acss)
  324.         if character == '\n':
  325.             self._send_command(self._client.sound_icon, 'end-of-line')
  326.         else:
  327.             self._send_command(self._client.char, character)
  328.  
  329.     
  330.     def speakKeyEvent(self, event_string, eventType):
  331.         if eventType == orca.KeyEventType.PRINTABLE:
  332.             if event_string.decode('UTF-8').isupper():
  333.                 acss = settings.voices[settings.UPPERCASE_VOICE]
  334.             else:
  335.                 acss = None
  336.             key = self.KEY_NAMES.get(event_string, event_string)
  337.             self._apply_acss(acss)
  338.             self._send_command(self._client.key, key)
  339.         else:
  340.             return super(SpeechServer, self).speakKeyEvent(event_string, eventType)
  341.         return eventType == orca.KeyEventType.PRINTABLE
  342.  
  343.     
  344.     def increaseSpeechRate(self, step = 5):
  345.         self._change_default_speech_rate()
  346.  
  347.     
  348.     def decreaseSpeechRate(self, step = 5):
  349.         self._change_default_speech_rate(decrease = True)
  350.  
  351.     
  352.     def increaseSpeechPitch(self, step = 0.5):
  353.         self._change_default_speech_pitch()
  354.  
  355.     
  356.     def decreaseSpeechPitch(self, step = 0.5):
  357.         self._change_default_speech_pitch(decrease = True)
  358.  
  359.     
  360.     def stop(self):
  361.         self._cancel()
  362.  
  363.     
  364.     def shutdown(self):
  365.         self._client.close()
  366.         del SpeechServer._active_servers[self._id]
  367.  
  368.     
  369.     def reset(self, text = None, acss = None):
  370.         self._client.close()
  371.         self._init()
  372.  
  373.     
  374.     def list_output_modules(self):
  375.         '''Return names of available output modules as a tuple of strings.
  376.  
  377.         This method is not a part of Orca speech API, but is used internally
  378.         by the Speech Dispatcher backend.
  379.         
  380.         The returned tuple can be empty if the information can not be
  381.         obtained (e.g. with an older Speech Dispatcher version).
  382.         
  383.         '''
  384.         
  385.         try:
  386.             return self._send_command(self._client.list_output_modules)
  387.         except AttributeError:
  388.             return ()
  389.             except speechd.SSIPCommandError:
  390.                 return ()
  391.             else:
  392.                 return None
  393.  
  394.  
  395.  
  396.